home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Cream of the Crop 1
/
Cream of the Crop 1.iso
/
PROGRAM
/
48ASMDBG.ARJ
/
SIM1.H
< prev
Wrap
C/C++ Source or Header
|
1992-04-09
|
18KB
|
717 lines
#include <stdio>
#include <string.h>
#include <stdlib>
#define STRTYP 0x02a2c
#define REATYP 0x02933
#define IMCTYP 0x02c96
#define ALGTYP 0x02ab8
#define PRGTYP 0x02d9d
#define NAMTYP 0x02e48
#define LOCTYP 0x02e67
#define BINTYP 0x02a4e
#define d0_init 0x000e9e52 /* any number, hopefully not required */
#define d1_init 0x000e9e54 /* top of display_stack */
#define st_init 0x00000000
#define b_init 0x76768576
#define d_init 0x29004976
/*now define contents of "known" locations (ie @d0, @d1...) */
#define RPL 0x000e9e53 /* address of next RPL ins */
#define ST0 (d1_init+0x100) /* pointer to stack level 0 */
#define ST1 (ST0 + 0x100)
#define ST2 (ST1 + 0x100)
#define ST3 (ST2 + 0x100)
#define ST4 (ST3 + 0x100)
/* now a few aliases */
#define mask_pa mask_p10
#define mask_pb mask_p11
#define mask_pc mask_p12
#define mask_pd mask_p13
#define mask_pe mask_p14
#define mask_pf mask_p15
typedef unsigned long reg_t[2];
reg_t tmp;
reg_t a,b={0,b_init},c,d={0,d_init};
reg_t r0,r1,r2,r3,r4;
reg_t d0={0,d0_init},d1={0,d1_init},pc={0,0},st={0,st_init},p={0,0};
unsigned char carry=0,stkptr=6,return_flag;
unsigned long stack[7]={0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xfffff
fff, 0xffffffff, 0xffffffff};
/* -------------------------------------------------------------------------
/* Screen functions for vt100 */
cls() /* clear screen */
{
printf("%c[2J",27);
}
ebl() /* erase bottom line */
{
bos();
printf("%c[2K",27);
}
tos() /* curser to top of screen */
{
printf("%c[H",27);
}
bos() /* curser to bottom of screen */
{
printf("%c[23;0H",27);
}
bold() /* bold text */
{
printf("%c[1m",27);
}
norm() /* normal text */
{
printf("%c[0m",27);
}
/* -------------------------------------------------------------------------
reg_t mask_1 = {0x00000000, 0x0000000f};
reg_t mask_2 = {0x00000000, 0x000000ff};
reg_t mask_3 = {0x00000000, 0x00000fff};
reg_t mask_4 = {0x00000000, 0x0000ffff};
reg_t mask_5 = {0x00000000, 0x000fffff};
reg_t mask_6 = {0x00000000, 0x00ffffff};
reg_t mask_7 = {0x00000000, 0x0fffffff};
reg_t mask_8 = {0x00000000, 0xffffffff};
reg_t mask_9 = {0x0000000f, 0xffffffff};
reg_t mask_10 = {0x000000ff, 0xffffffff};
reg_t mask_11 = {0x00000fff, 0xffffffff};
reg_t mask_12 = {0x0000ffff, 0xffffffff};
reg_t mask_13 = {0x000fffff, 0xffffffff};
reg_t mask_14 = {0x00ffffff, 0xffffffff};
reg_t mask_15 = {0x0fffffff, 0xffffffff};
reg_t mask_16 = {0xffffffff, 0xffffffff};
reg_t mask_w = {0xffffffff, 0xffffffff};
reg_t mask_a = {0x00000000, 0x000fffff};
reg_t mask_x = {0x00000000, 0x00000fff};
reg_t mask_s = {0xf0000000, 0x00000000};
reg_t mask_m = {0x0fffffff, 0xfffff000};
reg_t mask_b = {0x00000000, 0x000000ff};
reg_t mask_xs = {0x00000000, 0x00000f00};
reg_t mask_def= {0x00000000, 0x000fffff}; /* default - non .a defaults
should be
OK */
reg_t mask_p,mask_wp,mask_p1,mask_p2,mask_p3,mask_p4,mask_p5,mask_p6;
reg_t mask_p7,mask_p8,mask_p9,mask_p10,mask_p11,mask_p12,mask_p13;
reg_t mask_p14,mask_p15,mask_p16;
set_pmasks()
{
short int i;
p[1] &= mask_1[1];
p[0] = 0;
if (p[1] < 8)
{
mask_p[0] = 0x00000000;
mask_p[1] = 0x0000000f;
mask_wp[0] = 0x00000000;
mask_wp[1] = 0x0000000f;
for (i = 0; i < p[1]; ++i)
{
mask_p[1] == (mask_p[1] << (4*i));
mask_wp[1] |= mask_p[1];
}
}
else
{
mask_p[0] = 0x0000000f;
mask_p[1] = 0x00000000;
mask_wp[0] = 0x0000000f;
mask_wp[1] = 0x00000000;
for (i = 0; i < p[1]-8; ++i)
{
mask_p[0] == (mask_p[0] << (4*i));
mask_wp[0] |= mask_p[0];
}
}
mask_n(mask_p1,1);
mask_n(mask_p2,2);
mask_n(mask_p3,3);
mask_n(mask_p4,4);
mask_n(mask_p5,5);
mask_n(mask_p6,6);
mask_n(mask_p7,7);
mask_n(mask_p8,8);
mask_n(mask_p9,9);
mask_n(mask_p10,10);
mask_n(mask_p11,11);
mask_n(mask_p12,12);
mask_n(mask_p13,13);
mask_n(mask_p14,14);
mask_n(mask_p15,15);
mask_n(mask_p16,16);
}
mask_n(reg,n)
reg_t reg;
int n;
{
reg_t tmp1;
int i;
reg[0] = 0;
reg[1] = 0;
if (p[1] < 8)
{
for (i = p[1]; (i < 8)&&(i<(n+p[1])); ++i) reg[1] |= (0xf << (4*i));
if (i < (n+p[1])) {for (i = 0; (i < 8)&&(i<(n+p[1]-8)); ++i) reg[0]
|= (0xf<
< (4*i));}
}
else
{
for (i = p[1]; (i < 8)&&(i<(n+p[1])); ++i) reg[0] |= (0xf << (4*i));
}
}
move( mask, reg1, reg2)
reg_t mask, reg1, reg2;
{
short int i;
if (®1[0]==&pc[0]) printf("Ignoring <move pc,register> instruction...\n");
else
{
if ((&mask[0]==&mask_def[0]) &&
( (®1[0]==&r0[0])||(®2[0]==&r0[0])
||(®1[0]==&r1[0])||(®2[0]==&r1[0])
||(®1[0]==&r2[0])||(®2[0]==&r2[0])
||(®1[0]==&r3[0])||(®2[0]==&r3[0])
||(®1[0]==&r4[0])||(®2[0]==&r4[0]) )) {mask[0]=mask_w[0];
mask[1]=
mask_w[1];}
for (i = 0; i < 2; ++i) reg2[i] = (reg2[i] & (~mask[i])) | (reg1[i] &
mask[i
]);
if (®2[0]==&p[0]) set_pmasks();
}
}
swap( mask, reg1, reg2)
reg_t mask, reg1, reg2;
{
short int i;
reg_t tmp1;
if ((&mask[0]==&mask_def[0]) &&
( (®1[0]==&r0[0])||(®2[0]==&r0[0])
||(®1[0]==&r1[0])||(®2[0]==&r1[0])
||(®1[0]==&r2[0])||(®2[0]==&r2[0])
||(®1[0]==&r3[0])||(®2[0]==&r3[0])
||(®1[0]==&r4[0])||(®2[0]==&r4[0]) )) {mask[0]=mask_w[0];
mask[1]=ma
sk_w[1];}
for (i = 0; i < 2; ++i)
{
tmp1[i] = (reg2[i] & (~mask[i])) | (reg1[i] & mask[i]);
reg1[i] = (reg1[i] & (~mask[i])) | (reg2[i] & mask[i]);
reg2[i] = tmp1[i];
}
if (®2[0]==&p[0]) set_pmasks();
}
push()
{
stack[stkptr--] = c[0] & mask_a[0];
}
pop()
{
c[0] = ((c[0] & (~mask_a[0])) | (stack[stkptr++] & mask_a[0]));
}
clr( mask, reg1)
reg_t mask, reg1;
{
short int i;
for (i = 0; i < 2; i++) reg1[i] &= (~mask[i]);
}
and( mask, reg1, reg2)
reg_t mask, reg1, reg2;
{
short int i;
for (i = 0; i < 2; i++) reg2[i] = ((reg2[i] & (~mask[i])) | (reg2[i] &
mask[i]
& reg1[i]));
}
or( mask, reg1, reg2)
reg_t mask, reg1, reg2;
{
short int i;
for (i = 0; i < 2; i++) reg2[i] = ((reg2[i] & (~mask[i])) | ((reg2[i]
|reg1[i]
) & mask[i]));
}
inc( mask, reg1)
reg_t mask, reg1;
{
reg_t tmp1;
tmp1[0] = 0;
tmp1[1] = 1;
while (tmp1[1] && (!(tmp1[1] & mask[1]))) (tmp1[1] << 4);
if (!tmp1[1])
{
tmp1[0] = 1;
while (tmp1[0] && (!(tmp1[0] & mask[0]))) (tmp1[0] << 4);
}
add(mask,tmp1,reg1);
}
dec( mask, reg1)
reg_t mask, reg1;
{
reg_t tmp1;
tmp1[0] = 0;
tmp1[1] = 1;
while (tmp1[1] && (!(tmp1[1] & mask[1]))) (tmp1[1] << 4);
if (!tmp1[1])
{
tmp1[0] = 1;
while (tmp1[0] && (!(tmp1[0] & mask[0]))) (tmp1[0] << 4);
}
sub(mask,tmp1,reg1);
}
add( mask, reg1, reg2)
reg_t mask, reg1, reg2;
{
unsigned long t;
reg2[1] += (reg1[1] & mask[1]);
if ( (((reg2[1] >> 4) + (reg1[1] & mask[1])) >> 4) & 0xf0000000 )
{
t = reg2[0];
reg2[0] += ( (reg1[0]+1) & mask[0] );
carry = (t+((reg1[0]+1) & mask[0]) != reg2[0]);
}
else
{
t = reg2[0];
reg2[0] += ( reg1[0] & mask[0] );
carry = (t+(reg1[0] & mask[0]) != reg2[0]);
}
if (®2[0]==&p[0]) set_pmasks();
}
sub( mask, reg1, reg2)
reg_t mask, reg1, reg2;
{
unsigned long t;
reg2[1] -= (reg1[1] & mask[1]);
if ((reg2[1] & mask[1]) < (reg1[1] & mask[1]))
{
t = reg2[0];
reg2[0] -= ( (reg1[0]+1) & mask[0] );
carry = (t-((reg1[0]+1) & mask[0]) != reg2[0]);
}
else
{
t = reg2[0];
reg2[0] -= ( reg1[0] & mask[0] );
carry = (t-(reg1[0] & mask[0]) != reg2[0]);
}
if (®2[0]==&p[0]) set_pmasks();
}
not( mask, reg1)
reg_t mask, reg1;
{
carry = 0;
reg1[0] = (reg1[0] & (~mask[0])) | ((~reg1[0]) & mask[0]);
reg1[1] = (reg1[1] & (~mask[1])) | ((~reg1[1]) & mask[1]);
}
neg( mask, reg1)
reg_t mask, reg1;
{
not(mask,reg1);
dec(mask,reg1);
}
rrn( mask, reg1)
reg_t mask, reg1;
{
long i,store;
if (mask[1])
{
for (i=0xfL; (!(mask[1] & i)); i = i << 4);
store = reg1[1] & i;
}
else
{
for (i=0xfL; (!(mask[0] & i)); i = i < 4);
store = reg1[0] & i;
}
while (store > 0xfL) store = store >> 4;
srn(mask,reg1);
if (store)
{
if (mask[0])
{
for (i=0xf0000000L; (!(mask[0] & i)); i = i >> 4);
while (!(store & i)) store = store << 4;
reg1[0] |= store;
}
else
{
for (i=0xf0000000L; (!(mask[1] & i)); i = i >> 4);
while (!(store & i)) store = store << 4;
reg1[1] |= store;
}
}
}
rln( mask, reg1)
reg_t mask, reg1;
{
long i,store;
if (mask[0])
{
for (i=0xf0000000L; (!(mask[0] & i)); i = i >> 4);
store = reg1[0] & i;
}
else
{
for (i=0xf0000000L; (!(mask[1] & i)); i = i >> 4);
store = reg1[1] & i;
}
while (store > 0xfL) store = store >> 4;
sln(mask,reg1);
if (store)
{
if (mask[1])
{
for (i=0xfL; (!(mask[1] & i)); i = i << 4);
while (!(store & i)) store = store << 4;
reg1[1] |= store;
}
else
{
for (i=0xfL; (!(mask[0] & i)); i = i << 4);
while (!(store & i)) store = store << 4;
reg1[0] |= store;
}
}
}
srn( mask, reg1)
reg_t mask, reg1;
{
reg_t tmp1;
tmp1[1] = (((reg1[1] & mask[1]) >> 4L)|((reg1[0] & 0xfL) << 28L)) & mask[1];
tmp1[0] = (reg1[0] & mask[0]) >> 4L;
reg1[0] = (reg1[0] & (~mask[0])) | (tmp1[0] & mask[0]);
reg1[1] = (reg1[1] & (~mask[1])) | (tmp1[1] & mask[1]);
}
srb( mask, reg1)
reg_t mask, reg1;
{
reg_t tmp1;
tmp1[1] = (((reg1[1] & mask[1]) >> 1L)|((reg1[0] & 0x1L) << 31L)) & mask[1];
tmp1[0] = (reg1[0] & mask[0]) >> 1L;
reg1[0] = (reg1[0] & (~mask[0])) | (tmp1[0] & mask[0]);
reg1[1] = (reg1[1] & (~mask[1])) | (tmp1[1] & mask[1]);
}
sln( mask, reg1)
reg_t mask, reg1;
{
reg_t tmp1;
tmp1[1] = ((reg1[1] & mask[1]) << 4L) & mask[1];
tmp1[0] = (((reg1[0] & mask[0]) << 4L)|((reg1[1] & 0xf0000000L) >>
28L)) & mas
k[0];
reg1[0] = (reg1[0] & (~mask[0])) | (tmp1[0] & mask[0]);
reg1[1] = (reg1[1] & (~mask[1])) | (tmp1[1] & mask[1]);
}
constmp(mask, cons)
reg_t mask;
long cons;
{
short int i;
i = 0;
while ((1 << i) && !((1 << i) & mask[1])) i += 4;
if (!(1 << (i-8))) while ((1 << (i-8)) && !((1 << (i-8)) & mask[0])) i += 4;
tmp[1] = (mask[1] & ( cons << i ));
tmp[0] = (mask[0] & ( cons >> (8-i) ));
}
show_regs()
{
int i;
char strng1[17],strng2[17];
printf("----------------------------------------------------------------------
---------\n");
printf("| a=%08X%08X b=%08X%08X c=%08X%08X d=%08X%08X
|\n",a[0],a[1],b[0],b[1]
,c[0],c[1],d[0],d[1]);
printf("| d0 = %05X, d1 = %05X, status = %04X, p = %1X,
carr
y %s |\n",d0[1]&mask_a[1],d1[1]&mask_a[1],st[1]&mask_4[1],p[1],(carry) ?
"set "
:"clear");
printf("----------------------------------------------------------------------
---------\n");
}
input(fld, mask, reg1, reg2)
reg_t mask, reg1, reg2;
char fld[3];
{
char instr[17],str1[9],str2[17];
int i;
if((mask[0]==mask_a[0]) && (mask[1]==mask_a[1])) /* getting an address? */
{
switch (reg1[1]&mask_a[1]) /* is it known? */
{
case d0_init: {reg2[1]=(reg2[1] & (~mask[1])) | (RPL &
mask[1
]); return; break; }
case d1_init: {reg2[1]=(reg2[1] & (~mask[1])) | (ST0 &
mask[1
]); return; break; }
case (5 +d1_init): {reg2[1]=(reg2[1] & (~mask[1])) | (ST1
&mask[1]); re
turn; break; }
case (10+d1_init): {reg2[1]=(reg2[1] & (~mask[1])) | (ST2 &
mask[1]); r
eturn; break; }
case (15+d1_init): {reg2[1]=(reg2[1] & (~mask[1])) | (ST3 &
mask[1]); r
eturn; break; }
case (20+d1_init): {reg2[1]=(reg2[1] & (~mask[1])) | (ST4 &
mask[1]); r
eturn; break; }
case ST0: {intype(mask,reg2,1); return; break;}
case ST1: {intype(mask,reg2,1); return; break;}
case ST2: {intype(mask,reg2,2); return; break;}
case ST3: {intype(mask,reg2,3); return; break;}
case ST4: {intype(mask,reg2,4); return; break;}
case (ST0+5): {printf("Input from Stack[0]+5: "); break;}
case (ST0+10): {printf("Input from Stack[0]+10: "); break;}
case (ST1+5): {printf("Input from Stack[1]+5: "); break;}
case (ST1+10): {printf("Input from Stack[1]+10: "); break;}
case (ST2+5): {printf("Input from Stack[2]+5: "); break;}
case (ST2+10): {printf("Input from Stack[2]+10: "); break;}
case (ST3+5): {printf("Input from Stack[3]+5: "); break;}
case (ST3+10): {printf("Input from Stack[3]+10: "); break;}
case (ST4+5): {printf("Input from Stack[4]+5: "); break;}
case (ST4+10): {printf("Input from Stack[4]+10: "); break;}
}
}
for (i = 0; i < 16; ++i) instr[i] = 48;
instr[17] = 0;
for (i = 0; i < 8 && !( (1<<(4*i)) & mask[1]); ++i);
if (i == 8) for (i = 8;i < 16 & !( (1<<((4*i)-32)) & mask[0]); ++i);
printf("Input [%3s] field (in hex) stored at %05X: ",fld,(reg1[1] &
mask_a[1])
);
scanf("%s",str2);
printf("\n");
strncpy(&instr[16-i-strlen(str2)],str2,strlen(str2));
strncpy(str1,instr,8);
str1[8]=0;
reg2[0] = (reg2[0] & (~mask[0])) | (strtoul(str1,NULL,16) & mask[0]);
reg2[1] = (reg2[1] & (~mask[1])) | (strtoul(&instr[8],NULL,16) & mask[1]);
}
output(fld, mask, reg1, reg2)
reg_t mask, reg1, reg2;
char fld[3];
{
if (mask[0] && mask[1]) printf("[%s] field of @[%05X] <=
%x%0x\n",fld,reg2[1]&
mask_a[1],reg1[0]&mask[0],reg1[1]&mask[1]);
else if (mask[0] && !mask[1]) printf("[%s] field of @[%05X] <=
%x\n",fld,reg2[
1]&mask_a[1],reg1[0]&mask[0]);
else printf("[%s] field of @[%05X] is now
%x\n",fld,reg2[1]&mask_a[1],reg1[1]&
mask[1]);
}
intype(mask,reg2,lvl)
reg_t mask, reg2;
int lvl;
{
int i;
printf("Input type of object in level %d of display:\n\n (0)
String\n
(1) Real\n (2) Inline machine code\n (3) Algebraic
obj\n
(4) Programme\n (5) Global Name\n (6) Local Name\n
(7)
Binary Integer\n",lvl);
scanf("%d",&i);
switch (i)
{
case 0: {reg2[1]=(reg2[1] & (~mask[1])) | (STRTYP & mask[1]); break;}
case 1: {reg2[1]=(reg2[1] & (~mask[1])) | (REATYP & mask[1]); break;}
case 2: {reg2[1]=(reg2[1] & (~mask[1])) | (IMCTYP & mask[1]); break;}
case 3: {reg2[1]=(reg2[1] & (~mask[1])) | (ALGTYP & mask[1]); break;}
case 4: {reg2[1]=(reg2[1] & (~mask[1])) | (PRGTYP & mask[1]); break;}
case 5: {reg2[1]=(reg2[1] & (~mask[1])) | (NAMTYP & mask[1]); break;}
case 6: {reg2[1]=(reg2[1] & (~mask[1])) | (LOCTYP & mask[1]); break;}
case 7: {reg2[1]=(reg2[1] & (~mask[1])) | (BINTYP & mask[1]); break;}
default: printf("error, unknown type\n");
}
printf("\n");
}
getstep(char *cmd)
{
char cnt[5];
static int step_count=1;
printf ("%s\n",cmd);
if (!(--step_count))
{
tos();
bold();
show_regs();
bos();
printf("\n%c%c%c clr,set,qui,n-steps: ",9,9,9);
norm();
scanf("%s",cnt);
while ((!strcmp(cnt,"clr"))||(!strcmp(cnt,"set")))
{
if(!strcmp(cnt,"clr"))
{
cls();
bos();
printf ("%s",cmd);
printf ("\n"); /* for some reason, I need to do it this way on
my term
*/
}
else
{
bold();
printf("Enter name of register (a,b,c,d,d0,d1,st,p,car): ");
norm();
scanf("%s",cnt);
ebl();
if (!strcmp(cnt,"car"))
{
bold();
printf("Set/Clear? (s/c)");
norm();
scanf("%c",cnt);
if (cnt[0]==115) carry=1; else carry=0;
}
else if (!strcmp(cnt,"p"))
{
bold();
printf("Enter HEX value (1 nybble): ");
norm();
scanf("%1x",&p[1]);
set_pmasks();
}
else if (!strcmp(cnt,"st"))
{
bold();
printf("Enter HEX value (4 nybbles): ");
norm();
scanf("%4x",&st[1]);
}
else if (!strcmp(cnt,"d0"))
{
bold();
printf("Enter new value (in HEX) (5 nybbles): ");
norm();
scanf("%5x",&d0[1]);
}
else if (!strcmp(cnt,"d1"))
{
bold();
printf("Enter new value (in HEX) (5 nybbles): ");
norm();
scanf("%5x",&d1[1]);
}
else if (!strcmp(cnt,"a"))
{
bold();
printf("Enter new value (in HEX) (16 nyb incl leading 0s): ");
norm();
scanf("%16x",&a[0],&a[1]);
}
else if (!strcmp(cnt,"b"))
{
bold();
printf("Enter new value (in HEX) (16 nyb incl leading 0s): ");
norm();
scanf("%16x",&b[0],&b[1]);
}
else if (!strcmp(cnt,"c"))
{
bold();
printf("Enter new value (in HEX) (16 nyb incl leading 0s): ");
norm();
scanf("%16x",&c[0],&c[1]);
}
else if (!strcmp(cnt,"d"))
{
bold();
printf("Enter new value (in HEX) (16 nybs incl leading 0s): ");
norm();
scanf("%16x",&d[0],&d[1]);
}
else printf("Illegal register name - ignored");
printf("\n");
}
tos();
bold();
show_regs();
bos();
printf("\n%c%c%c clr,set,qui,n-steps: ",9,9,9);
norm();
scanf("%s",cnt);
}
if (!strcmp(cnt,"qui"))
{
cls();
tos();
exit(0);
}
ebl();
step_count=strtol(cnt,NULL,10);
if (!step_count) step_count = 1;
}
}